Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@docs/admin-portal/overview.md`:
- Around line 125-202: The docs still contain Blazor/Razor examples
(AuthorizeView, `@attribute`, `@inject` LocalizationService, MudButton/MudText,
DialogService.ShowMessageBox); replace these with React/TSX examples using your
app conventions: show a ProtectedPage component using next-auth's useSession (or
your auth hook) to gate UI (e.g., ProtectedPage -> const { data: session } =
useSession(); session?.user?.role === 'admin' ? <Button>Editar</Button> :
<Text>Sem permissão</Text>), replace `@inject` LocalizationService L and
L.GetString(...) with your i18n hook (e.g., const { t } = useTranslation();
<Button>{t('Common.Save')}</Button>), and swap DialogService.ShowMessageBox
examples for your React dialog API or a window.confirm fallback (e.g.,
showModal/showConfirm or custom <ConfirmDialog />); update code blocks and
explanatory text accordingly so all examples use React/TSX symbols
(ProtectedPage, useSession, useTranslation, Button, Text, showModal).
- Around line 35-102: The docs still describe a Blazor WASM architecture and
.razor/Fluxor artifacts; update the Mermaid diagram (replace "Admin Portal
(Blazor WASM)" and nodes State, Effects, API labeled as Fluxor/Refit with
Next.js/React, Zustand (or equivalent) and TanStack Query and adjust arrows
accordingly using the existing node names (UI, State, Effects, API, Gateway,
Modules) or renaming UI->ReactComponents and State->Zustand/Store so the flow
maps to API Gateway and Backend modules; also replace the directory tree under
src/Web/MeAjudaAi.Web.Admin/ to reflect the React/Next.js layout by removing
.razor files and the Features/Fluxor folder and adding app/, (admin)/,
components/, hooks/, lib/ (keep references to package.json/Next.js where
applicable) so the file list and diagram match the Sprint 8D migration.

In `@docs/architecture.md`:
- Around line 2829-3110: This section contains ~280 lines of obsolete
Blazor/Fluxor/Refit/MudBlazor examples (notably ProvidersState,
ProvidersActions, ProvidersReducers, ProvidersEffects, IProvidersApi,
IDocumentsApi, IServiceCatalogsApi, MudDataGrid, MudPagination, MudCard, etc.)
that conflict with the React/Next.js migration; remove these legacy blocks from
docs/architecture.md and either (a) move them into a new historical file (e.g.,
docs/admin-portal/legacy/blazor-architecture.md) preserving the original
content, or (b) replace them with concise React equivalents (e.g., mention
Zustand store patterns and TanStack Query hooks plus example filenames like
stores/providersStore.ts and hooks/useProviders.ts) so the architecture doc
reflects the current Admin Portal tech stack.

In `@docs/roadmap.md`:
- Line 36: Atualize a linha que atualmente diz "Admin Portal atualmente em
Blazor WASM; migração para React planejada para o Sprint 8D." para refletir que
o Sprint 8D foi concluído em 24 de março de 2026; altere o texto para algo como
"Admin Portal migrado de Blazor WASM para React durante o Sprint 8D (concluído
em 24 de março de 2026)." e garanta que qualquer menção a "planejada" ou
"planejada para o Sprint 8D" seja removida ou convertida para status concluído.

In `@README.md`:
- Around line 107-108: The README's project tree still labels
MeAjudaAi.Web.Admin as "Admin Portal (Blazor WASM)"; update that entry to
reflect the completed migration to React (e.g., "Admin Portal (React)") so it
matches the Sprint 8D changes and PR description; locate the line referencing
the MeAjudaAi.Web.Admin folder in README.md and replace the platform note
accordingly.

---

Nitpick comments:
In `@docs/roadmap-current.md`:
- Around line 617-637: The Sprint 8E doc incorrectly lists "Setup Playwright" in
the Scope even though Playwright is already present in src/Web/package.json;
update the "### ⏳ Sprint 8E - E2E Tests React Apps (Playwright)" section to
remove or de-emphasize "Setup Playwright" and instead replace it with explicit
implementation tasks (e.g., "Implement Playwright test specs and test suites",
"Add CI steps for Playwright in pr-validation.yml and master-ci-cd.yml") and
adjust the Status/Branch notes as needed so the Scope reflects implementing
tests (the heading text, the Scope list, and the first bullet "Setup Playwright"
are the identifiers to edit).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Web/e2e/admin/providers.spec.ts`:
- Around line 12-16: The test "should search providers" uses a weak success
criterion (.toBeVisible()) which can produce false positives; update the test
that fills searchInput (variable searchInput) to assert that the provider rows
(locator '[data-testid="provider-row"]') actually reflect the query by checking
their text content includes the search term (e.g., contains 'João') and/or that
non-matching rows are not visible, and optionally assert the count of matched
rows changes compared to an unfiltered state; apply the same stronger assertions
to the analogous filter test(s) that currently only call .toBeVisible().
- Around line 31-40: The two tests named "should approve document" and "should
reject document" are racing for the same pending document because they use
generic selectors (page.goto('/admin/documentos') and
button:has-text("Aprovar"/"Rejeitar")) and run fullyParallel; add isolation by
creating a unique fixture per test in test.beforeEach (call your backend API or
test helper to create/reset a single pending document and return its id), then
target that specific document in each test (use a deterministic selector
containing the returned id or navigate to the document-specific URL) and ensure
teardown/reset after each test so the approve and reject flows operate on
independent documents.

In `@src/Web/e2e/base.ts`:
- Around line 5-9: O fixture estendido test = base.extend({ page: async ({ page
}, use) => { await page.goto('/'); await use(page); }, }) está navegando
automaticamente para '/' antes de cada teste, causando navegação duplicada com
os test.beforeEach dos specs (por exemplo provider/onboarding.spec.ts); remova a
chamada await page.goto('/') do fixture (ou alternativamente delete os
beforeEach redundantes nos specs que também navegam para '/'), deixando que cada
spec controle sua própria navegação; edite a função page no extend para apenas
usar(page) sem navegar.

In `@src/Web/e2e/customer/auth.spec.ts`:
- Around line 12-15: No teste "should navigate to login page" substitua a
asserção que usa expect(page.url()).toContain('/login') por uma asserção
auto-retrying: após page.click('text=Entrar') use await
expect(page).toHaveURL(...) (por exemplo await
expect(page).toHaveURL(/.*\/login/) ou await expect(page).toHaveURL('**/login')
) para aguardar a navegação e evitar flakiness.

In `@src/Web/e2e/customer/search.spec.ts`:
- Around line 19-24: In the 'should filter by location' test, remove the leading
space from the input value passed to locationInput.fill — replace ' Rio de
Janeiro' with 'Rio de Janeiro' in the test body (the test function named "should
filter by location" using the locator stored in locationInput) so the test sends
the correct string without the stray leading whitespace.

In `@src/Web/e2e/provider/auth.spec.ts`:
- Around line 12-15: O teste "should navigate to login page" usa
page.click('text=Login Prestador') e atualmente verifica
expect(page.url()).toContain('/login') — atualize essa asserção para verificar o
path correto (por exemplo '/provider/login') para evitar falsos positivos;
localize a declaração do teste (test('should navigate to login page', async ({
page }) => { ... })) e substituir a expectativa por uma verificação mais
específica como expect(page.url()).toContain('/provider/login') ou a string de
rota correta da aplicação.

In `@src/Web/e2e/provider/onboarding.spec.ts`:
- Around line 12-18: O teste "should complete basic info step" está usando um
CPF inválido (12345678900) que pode acionar validação e quebrar o teste; update
o CPF value usado in the test to a known-valid test CPF (e.g. 52998224725) in
the page.fill call for 'input[name="cpf"]' so the form validation passes and the
assertion that the URL contains '/onboarding/documentos' can be reached.

In `@src/Web/playwright.config.ts`:
- Around line 40-45: No script `next:dev` exists; update the Playwright
webServer configuration's command (webServer.command) to use the correct Next.js
start script by replacing 'npm run next:dev' with 'npm run dev' so Playwright
launches the app with the defined package.json script.

---

Nitpick comments:
In @.github/workflows/master-ci-cd.yml:
- Around line 167-179: O job "Run E2E Tests (Playwright)" tem espaços em branco
finais e instala apenas chromium mas executa todos os projetos; remova os
trailing spaces nas linhas correspondentes (as linhas onde aparecem espaços ao
final) e alinhe os comandos: mantenha "npx playwright install --with-deps
chromium" como instalador e altere o test runner "npx playwright test
--reporter=list" para filtrar o projeto instalado (por exemplo adicionando
"--project=chromium") para que apenas o projeto chromium seja executado.

In @.github/workflows/pr-validation.yml:
- Around line 182-194: O step "Run E2E Tests (Playwright)" instala apenas
Chromium via "npx playwright install --with-deps chromium" enquanto
"playwright.config.ts" define cinco projects; isso fará os testes falharem para
browsers não instalados. Corrija instalando todos os browsers usados (remover
"chromium" para rodar "npx playwright install --with-deps" sem filtro) ou altere
a execução "npx playwright test --reporter=list" para usar o filtro de projeto
correspondente (ex.: "--project=chromium" ou listar explicitamente os projetos
instalados) de modo que os projects em playwright.config.ts correspondam aos
browsers instalados.

In `@src/Web/e2e/admin/auth.spec.ts`:
- Around line 12-15: Replace the non-waiting assertion that checks the URL after
clicking "Login Admin": after calling page.click('text=Login Admin') use
Playwright's auto-waiting assertion await expect(page).toHaveURL(...) instead of
expect(page.url()).toContain(...); update the test named 'should navigate to
login' to await the navigation with expect(page).toHaveURL (use the
'/admin/login' path or a suitable pattern) so the test reliably waits for the
route change.
- Around line 23-29: The test "should show error for invalid credentials" uses a
case-sensitive locator 'text=credenciais inválidas' which will break on
capitalization or minor text changes; update the assertion to perform a
case-insensitive match (for example use a case-insensitive regex or normalize
the locator text) when checking the error message so the expect on the locator
(currently referencing 'text=credenciais inválidas') becomes robust to casing
and small variations.

In `@src/Web/e2e/customer/auth.spec.ts`:
- Around line 8-10: A asserção no teste 'should display landing page' está
demasiado genérica (usa page.locator('h1')); substitua-a por uma verificação
mais específica: localizar o heading esperado por texto/role ou por um seletor
data-testid (ex.: page.getByRole('heading', { name: 'Texto Esperado' }) ou
page.locator('[data-testid="landing-heading"]')) e usar
toBeVisible()/toHaveText() conforme apropriado para validar conteúdo e evitar
falsos positivos.
- Around line 23-29: The test "should show error for invalid credentials" uses a
fragile text selector; change the assertion to target the ARIA alert role
instead (use page.getByRole('alert') with a case-insensitive regex) so it no
longer depends on exact UI/i18n text; update the assertion referencing the
existing test block and replace the expect(page.locator('text=credenciais
inválidas')).toBeVisible() with an expectation against
page.getByRole('alert').toContainText(/credenciais inválidas/i) (or similar
regex) to make the check robust.

In `@src/Web/playwright.config.ts`:
- Around line 18-39: The Playwright config's projects array declares five
projects ('chromium', 'firefox', 'webkit', 'Mobile Chrome', 'Mobile Safari') but
the CI only installs Chromium, causing CI E2E failures; fix by either installing
all browsers in CI or limiting CI runs to Chromium — the minimal change is to
add a CI-only profile or update the CI test invocation to pass
--project=chromium (or create a new profile in the Playwright config that only
includes the 'chromium' project and have CI use that profile) so CI only runs
the supported browser.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/admin-portal/overview.md`:
- Around line 99-101: Atualize o trecho em docs/admin-portal/overview.md que
lista "e2e/" e "playwright.config.ts" para refletir a localização real dos
artefatos; substitua as entradas por "src/Web/e2e/" e
"src/Web/playwright.config.ts" (ou equivalente usado no workspace) garantindo
que o exemplo de árvore mostre essas pastas/arquivos corretamente e mantenha a
formatação consistente com o restante do documento.
- Around line 145-146: Replace the non-existent <Redirect /> usage in the
AdminProtected client component with next/navigation's router.push: import
useRouter from 'next/navigation', call const router = useRouter(), and return
router.push('/login') instead of rendering <Redirect />; also ensure you handle
the loading state (status === 'loading') with Spinner and keep the existing role
check (session.user.role !== 'admin') returning <AccessDenied /> so the flow is:
useSession -> handle loading -> if no session call router.push('/login') -> if
not admin return <AccessDenied />.

In `@docs/architecture.md`:
- Around line 3254-3273: The docs mix React/Next and Blazor artifacts in the
same tree; remove Blazor-specific entries (Program.cs, App.razor,
MeAjudaAi.Web.Admin.Tests) from the apps/admin-portal React tree and either move
them into a separate Blazor app section or create a distinct
apps/admin-portal-blazor subtree; update the diagram so that the React structure
only contains Next.js files (src/app, components, hooks, lib, stores, e2e,
playwright.config.ts, package.json) and ensure any references to
Program.cs/App.razor/MeAjudaAi.Web.Admin.Tests are relocated to the
Blazor-specific documentation area.
- Line 3038: Update the documentation line that currently claims "✅ Reutilizável
entre projetos (.NET, Node.js)" by removing the Node.js reference and clarifying
Refit's platform support; replace that phrase with something like "✅
Reutilizável entre projetos .NET (ex.: .NET 6/8, Xamarin, Blazor, UWP) / .NET
Standard 2.0" or equivalent wording to state Refit is .NET/C# only and does not
officially support Node.js, referencing the library name "Refit" for locating
the text to change.

In `@docs/roadmap-current.md`:
- Around line 1214-1216: The summary line for "Sprint 8E: E2E Tests React Apps
(Playwright)" is set to "Planejada" but the sprint block indicates it is "EM
ANDAMENTO"; update the summary entry for that exact string to match the sprint
block by changing its status and icon to the same "EM ANDANDO"/in‑progress label
used in the sprint block (i.e., replace "Planejada" and its icon with the
in‑progress wording/icon used elsewhere) so both occurrences of "Sprint 8E: E2E
Tests React Apps (Playwright)" are identical.
- Around line 604-606: O título "### ✅ Sprint 8D - Admin Portal Migration (2 -
22 Abr 2026)" e a linha "**Status**: ✅ CONCLUÍDA (24 Mar 2026)" estão em
conflito; atualize um para que ambas as datas coincidam — por exemplo, setar a
data de conclusão para "22 Abr 2026" na linha de status ou alterar o intervalo
no título para "(2 - 24 Mar 2026)"; modifique as strings exatas "### ✅ Sprint 8D
- Admin Portal Migration (2 - 22 Abr 2026)" e "**Status**: ✅ CONCLUÍDA (24 Mar
2026)" para a opção corrigida e verifique consistência em quaisquer referências
posteriores a Sprint 8D no documento.

In `@docs/roadmap.md`:
- Around line 10-11: The roadmap lists "Sprint 8E" both as the current sprint
and again under "Próximas Sprints"; update the bullet list so the upcoming
sprints start with the next sequential sprint (e.g., change the first entry
under "Próximas Sprints" from "8E (E2E Tests)" to "9 (Buffer & Risk Mitigation)"
or otherwise remove the duplicate "8E"), ensuring the "Sprint Atual" line
remains "8E (E2E Tests)" and the "Próximas Sprints" list no longer contains
"Sprint 8E".

In `@README.md`:
- Around line 272-273: A seção do Admin Portal está com texto híbrido (menciona
Blazor apesar de os bullets serem "Admin Portal React com Tailwind CSS" e "E2E
Tests com Playwright"); abra a seção que contém o título/descrição atual do
Admin Portal e substitua a descrição introdutória que refere Blazor por uma que
mencione React e Tailwind (ou remova qualquer referência a Blazor), garantindo
que o cabeçalho "Admin Portal React com Tailwind CSS" e a frase introdutória
estejam coerentes com os bullets e com os testes E2E com Playwright.

---

Outside diff comments:
In `@docs/architecture.md`:
- Around line 2916-2931: Remover trecho órfão de Fluxor/C# que foi deixado após
o bloco TypeScript; localize e apagar o bloco que contém dispatcher.Dispatch e
LoadProvidersFailureAction (o catch/else com result.Error?.Message e
dispatcher.Dispatch(new LoadProvidersFailureAction(...))) que aparece
imediatamente depois do exemplo de TanStack Query/TypeScript para que o
documento contenha apenas o exemplo TypeScript relevante e não código C# fora de
contexto.

---

Nitpick comments:
In @.github/workflows/master-ci-cd.yml:
- Around line 167-179: Padronize o path do campo working-directory no job "Run
E2E Tests (Playwright)" para usar o prefixo ./ como no outro workflow; atualize
o valor atual "src/Web" para "./src/Web" (localize pelo nome do job "Run E2E
Tests (Playwright)" e pela chave working-directory) para manter consistência
entre os workflows.

In @.github/workflows/pr-validation.yml:
- Around line 182-194: Replace the hardcoded "if: false" on the "Run E2E Tests
(Playwright)" step with a dynamic conditional driven by a workflow input or
environment variable so the step can be enabled manually (e.g., via
workflow_dispatch) without editing the file; locate the step named "Run E2E
Tests (Playwright)" in the workflow and change its conditional to reference an
input (like inputs.run_e2e == 'true') or an env var (like env.RUN_E2E ==
'true'), and update the workflow inputs/defaults or env setup accordingly to
provide a clear on/off toggle for future activation.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In @.github/workflows/master-ci-cd.yml:
- Around line 167-179: Add the missing frontend build steps before the "Run E2E
Tests (Playwright)" step and enable that step: in
.github/workflows/master-ci-cd.yml, insert the same build sequence used in
pr-validation.yml for the ./src/Web workspace (run npm install in ./src/Web and
then npm run build for the Next.js apps) so the Playwright tests have a built
app to run against, and then remove the if: false guard from the "Run E2E Tests
(Playwright)" step (working-directory: ./src/Web) to enable E2E execution.

In `@docs/admin-portal/overview.md`:
- Around line 217-226: E2E tests in src/Web/e2e/admin/auth.spec.ts assume
email/password inputs that no longer exist because login uses Keycloak OAuth
(see src/Web/MeAjudaAi.Web.Admin/app/login/page.tsx with the "Entrar com
Keycloak" button); update the tests to exercise the OAuth flow instead: replace
queries for input[type="email"] and input[type="password"] with assertions that
clicking the Keycloak button triggers a navigation to the Keycloak auth URL, add
a route/network intercept or mock for the OAuth callback to simulate a
successful token exchange, and then assert the app redirects to /dashboard;
ensure tests verify the redirect and session state rather than non-existent form
fields.

In `@docs/architecture.md`:
- Around line 3224-3240: The docs' file tree incorrectly implies a multi-project
Playwright setup; update the wording in docs/architecture.md to reflect the
actual src/Web/playwright.config.ts implementation by stating that the
Playwright config defines browser/device projects via the projects array (e.g.,
entries like 'chromium', 'firefox', 'webkit', mobile devices) and that all tests
use a single testDir ('./e2e') and a single baseURL ('http://localhost:3000'),
rather than separate app-specific projects (admin/customer/provider); reference
the projects array, testDir and baseURL symbols when editing the text or
removing/annotating the src/Web/playwright.config.ts line in the tree so readers
aren’t misled about per-app Playwright projects.

In `@docs/roadmap-current.md`:
- Around line 624-630: The roadmap incorrectly marks CI integration as complete;
update the Sprint 8E scope line (the bullet referencing "CI Integration" /
"Adicionar steps em `pr-validation.yml` e `master-ci-cd.yml`") to reflect that
CI is pending (suggested text: "Setup Playwright completo, integração CI
pendente") OR enable the pipelines by modifying `pr-validation.yml` to remove
the conditional `if: env.RUN_E2E == 'true'` defaulting to false (or set the
default to 'true') and re-enable master pipeline E2E steps by changing `if:
false` in `master-ci-cd.yml`; reference `env.RUN_E2E`, `pr-validation.yml`, and
`master-ci-cd.yml` when making the change.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/admin-portal/overview.md`:
- Around line 242-244: The README command for running Playwright E2E tests
points at a non-existent path; update the example under the cd src/Web step to
reflect the repository's Playwright discovery rules (testDir: './src' and grep:
/e2e/) by replacing the incorrect invocation `npx playwright test e2e/admin/`
with either `npx playwright test --grep "admin"` to run only admin tests or `npx
playwright test` to run all E2E tests so the documented commands match the
Playwright config and actual test discovery.

---

Outside diff comments:
In `@docs/admin-portal/overview.md`:
- Around line 272-276: The "## 🔗 Links Úteis" section still references
Blazor/MudBlazor/Fluxor docs; update that Links Úteis block to point to React
and Next.js ecosystem docs instead (e.g., React docs, Next.js docs, and any
UI/state libraries your project uses such as Tailwind, MUI, or Redux). Locate
the "## 🔗 Links Úteis" heading in overview.md and replace the three
Blazor-specific URLs with the current recommended resources (React, Next.js, and
the project's chosen UI/state library) and ensure link text is in Portuguese to
match the document style.

In `@docs/architecture.md`:
- Around line 3012-3075: The docs section mixes Blazor/MudBlazor examples with
the React migration; replace or remove the MudBlazor/Razor snippets (e.g.,
<MudDataGrid>, <MudCard>, <MudText>, Razor syntax like
`@context/`@State/@TotalPages) and provide React+Tailwind equivalents (or plain
React component pseudo-code) that match the surrounding Layout/AppBar/Drawer
examples, ensuring props and behavior (pagination, KPI cards, status chip) are
represented using React component names and JSX syntax.

---

Duplicate comments:
In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Line 1: Os testes importam loginAsAdmin mas não o usam; adicione uma chamada a
loginAsAdmin() dentro de um beforeEach para cada suite de testes que exige
autenticação (as duas describes "Admin Portal - Providers Management" e "Admin
Portal - Documents") para evitar redirecionamento ao /admin/login. Localize os
blocos describe correspondentes e inserir beforeEach(async () => await
loginAsAdmin()) antes dos seus testes para garantir que as páginas admin estejam
autenticadas.

---

Nitpick comments:
In @.github/workflows/master-ci-cd.yml:
- Around line 187-188: The long shell command assigning DLL_PATH exceeds 120
chars; split it for readability by breaking the find invocation across lines or
by predefining parts: e.g., set a DIR_VAR and PATTERN_VAR (or use a multiline
command substitution with backslashes) and then assign DLL_PATH using those
smaller pieces (referencing the DLL_PATH variable and the find | head -n 1
pipeline), then call swagger tofile --output ../api/api-spec.json "$DLL_PATH" v1
as before; ensure quoting is preserved and line continuations or separate
variables keep the same semantics.

In `@docs/admin-portal/overview.md`:
- Around line 107-112: The fenced code block that contains the tree snippet
starting with "tests/MeAjudaAi.Web.Admin.Tests/" is missing a language specifier
and triggers markdownlint MD040; update that block to include a language
identifier (e.g., change the opening fence to ```text or ```bash) so the block
is explicitly annotated and the MD040 warning is resolved.

In `@src/Web/libs/e2e-support/base.ts`:
- Line 1: The import list at the top of the file includes an unused symbol
BrowserContext; remove BrowserContext from the import statement (import { test
as base, Page } from '@playwright/test') and verify there are no remaining
references to BrowserContext in this module (e.g., in helper functions or type
annotations) before committing.
- Around line 9-13: The custom fixture declared via test =
base.extend<TestFixtures> defines a page fixture that just forwards Playwright's
page (page: async ({ page }, use) => { await use(page); }) which is redundant;
either remove this custom page fixture and export test = base directly, or
implement the intended customization (e.g., automatic auth injection, additional
setup/teardown) inside the page fixture and add a short inline comment
explaining the purpose; locate and update the test constant and the page fixture
implementation to apply one of these two changes.
- Around line 41-44: No logout selector should rely on fragile text; in the
logout function replace the page.click('text=Sair') use a robust selector such
as page.getByRole('button', { name: /sair/i }) or a stable data-testid (e.g.
page.getByTestId('logout-button')) so the click targets the logout button by
role/aria or test id; update the logout(Page) implementation to use that
selector (and ensure the app exposes the matching aria-label or data-testid) and
keep the existing await page.waitForURL(...) as is.
- Around line 17-23: The current silent .catch() on page.waitForURL in
loginAsAdmin (and the same pattern in loginAsProvider and loginAsCustomer) masks
real failures; update each login helper to explicitly handle Playwright
TimeoutError vs other exceptions: call page.waitForURL(...) inside a try/catch,
and in the catch inspect error.name or error.message (e.g., "TimeoutError") to
treat only expected timeouts as the mock/test-mode case (log a specific message)
while rethrowing or failing-fast for any other errors (navigation failures,
element-not-found, etc.), and consider splitting the click and wait steps so
element-not-found errors can be caught and reported separately.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/auth.spec.ts`:
- Line 1: The imports loginAsCustomer and logout are unused in the test suite;
remove them from the import statement (the line that currently imports test,
expect, loginAsCustomer, logout from '@meajudaai/web-e2e-support') so only
needed symbols (test, expect) are imported, or alternatively use those functions
in an authentication test if intended—update the import to eliminate the unused
identifiers to fix the lint/cleanup warning.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/admin-portal/overview.md`:
- Line 119: Remove the stray closing Markdown code fence at the end of the code
block (the lone "```" shown) so the code block is properly balanced; locate the
unmatched closing fence in the overview.md around the end of the example and
delete it (or add a matching opening fence if the intention was to start a new
block), then preview the markdown to confirm subsequent sections render
correctly.

In `@docs/architecture.md`:
- Around line 3183-3202: The provided Playwright test uses email/password login
but the project e2e helper (src/Web/libs/e2e-support/base.ts) expects an OAuth
flow via the Keycloak button; update the test in Providers Management to perform
the OAuth login flow: replace the direct page.fill calls and click on
'[data-testid="login-button"]' with the Keycloak-triggering action (click the
Keycloak login button used by the shared helper) and then await the
redirect/validation logic provided by the e2e support (reuse the same
await/validation pattern from the e2e-support base helper), ensuring the test
still navigates to '/admin/providers' and asserts
'[data-testid="providers-table"]' visibility.
- Around line 2897-2903: The hook useProviders currently uses the removed
keepPreviousData option; update the useQuery options to use placeholderData
instead: import keepPreviousData from '@tanstack/react-query' and set
placeholderData: keepPreviousData, or use placeholderData: (previousData) =>
previousData; adjust the return in useProviders (and keep the existing queryKey
and queryFn that call providersApi.getProviders) so TanStack Query v5 preserves
previous page data correctly.

In `@docs/roadmap-current.md`:
- Line 630: The CI note under "7. **CI Integration**" contains a Spanish word
"pendiente" and should be changed to Portuguese pt-BR; update the text in the
docs/roadmap-current.md entry for "7. **CI Integration**" replacing "pendiente"
with "pendente" and scan the same sentence referencing `pr-validation.yml`,
`master-ci-cd.yml` and `RUN_E2E='true'` to ensure all other words use pt-BR
spelling consistently.
- Line 610: Update the checklist item that currently reads "✅ **Admin Portal
React**: Functional `apps/admin-portal`" to reference the correct Admin Portal
location by replacing `apps/admin-portal` with `src/Web/MeAjudaAi.Web.Admin/` so
the roadmap points to the existing React admin project (match the style used for
Customer/Provider entries).

In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Around line 46-55: The test "should approve document" uses non-existent
selectors (data-testid="document-approve"/"document-reject") and only asserts an
alert; update the flow to open the provider detail and assert state change:
navigate to '/admin/documentos', click the first provider's "eye" icon (use the
visual/icon locator used elsewhere in the app to open details), click the
visible "Aprovar" button in the detail view, assert success alert appears,
assert you return to the listing, and finally assert that the provider no longer
appears in the pending list; alternatively if approval must happen from the
list, add proper data-testid attributes to the list buttons and update the
selectors in the test (referencing the test name and the Eye/detail view and the
"Aprovar" button to locate code changes).

---

Outside diff comments:
In `@docs/admin-portal/overview.md`:
- Around line 129-130: Replace the outdated Blazor WASM redirect URIs
`/authentication/login-callback` and `/authentication/logout-callback` with the
NextAuth callback pattern `/api/auth/callback/[provider]` and specifically
update to `https://localhost:7001/api/auth/callback/keycloak`; ensure the docs
mention NextAuth.js v4 and that the provider segment is `keycloak` so readers
configure Keycloak redirects correctly.

In `@docs/architecture.md`:
- Around line 3212-3236: Remove the misplaced C#/bUnit test block (the
RenderComponent<Providers>() usages, _mockDispatcher.Verify,
Providers_Should_Display_Loading_State test, and Mud progress references like
".mud-progress-circular") from the “Estrutura de Arquivos (React)” section and
either move it to the Blazor/Tests documentation or replace it with the correct
React file-structure example and React-specific snippets for Providers; ensure
references to RenderComponent, _mockDispatcher,
Providers_Should_Display_Loading_State, and Mud classes are not left in the
React section.

---

Duplicate comments:
In `@docs/admin-portal/overview.md`:
- Around line 68-100: The docs tree under apps/admin-portal/ is inconsistent
with the actual workspace layout (which uses src/Web/...); update the overview
to reflect the real directories and filenames used in the repo by replacing
references to apps/admin-portal/ and its child folders with the corresponding
src/Web/... structure used elsewhere in the docs (ensure entries for the App
Router, components, hooks, stores, lib, and types match the real module names
such as the Web Admin app folder and any actual folder names like
MeAjudaAi.Web.Admin or similar), and make the same corrections in the repeated
section around lines 104-114 so all path examples point to the canonical
workspace layout used across the docs.

In `@docs/architecture.md`:
- Around line 3254-3255: A documentação está desatualizada: atualize a
referência de testDir no documento para casar com a configuração atual do
Playwright; altere a entrada documentada de testDir de './tests' para './src'
(ou, se preferir manter './tests', atualize o Playwright config em
playwright.config.ts para usar './tests'), verificando a chave testDir na
configuração do Playwright para garantir consistência entre docs e código.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Around line 26-33: The test 'should filter by status' currently only checks
visibility which can give false-positives; update the assertion using the
existing providerRows locator to verify the filter actually applied by asserting
each visible row's status cell contains the expected "Ativos"/"Ativo" text
(e.g., locate status within providerRows via a status selector like provider-row
>> [data-testid="provider-status"] or similar) or assert the list length matches
an expected filtered count; replace the single toBeVisible() check with a
stronger expectation using toHaveCount()/toContainText() or iterate through
providerRows and assert textContent for the status.

Verify each finding against the current code and only fix it if needed.

Outside diff comments:
In `@docs/architecture.md`:
- Around line 2891-3010: The Refit (.NET) content (interfaces like
IProvidersApi, IDocumentsApi, IServiceCatalogsApi and the AddRefitClient
registration) is misplaced in the Frontend React chapter; move that entire Refit
section to a backend or ".NET Client SDK" chapter (e.g.,
docs/backend/client-sdk.md) and replace it here with React/TypeScript
instructions: document using TypeScript types from types/api/generated, an API
wrapper function (e.g., getProviders), and TanStack Query hooks (useProviders,
useCreateProvider) that call that wrapper; also update the reference at the end
to point to the new .NET SDK doc instead of
src/Web/MeAjudaAi.Web.Customer/types/README.md.

In `@docs/roadmap-current.md`:
- Around line 669-676: Update "Risk Scenario 3: React Performance Issues" to
remove Blazor-specific mitigations ("Implementar lazy loading de assemblies",
"AOT compilation") and replace them with React/Next.js appropriate actions: list
"Code splitting with dynamic imports", "Tree shaking and bundle optimization",
"SSR/SSG via Next.js to improve initial load", "Lazy load React components", and
"Optimize images using next/image and responsive formats"; ensure the mitigation
bullet list under "Mitigação Sprint 9" uses these React/Next.js terms and
preserves impact and timeframe language.

---

Nitpick comments:
In `@src/Web/libs/e2e-support/base.ts`:
- Around line 13-23: handleLoginRedirect currently treats a TimeoutError as a
benign mock-mode signal which can hide real login failures; modify
handleLoginRedirect(Page) to, after a timeout from page.waitForURL, perform a
deterministic post-login verification (e.g., check for a known logged-in
selector like a user avatar or logout button, or verify a session cookie/token)
and only swallow the timeout if that verification proves mock-mode login is
present, otherwise rethrow or fail the test; reference the existing waitForURL
call and add a follow-up check (selector existence or cookie via
page.context().cookies()) to decide whether to treat the timeout as expected.
- Around line 25-41: The login helpers (loginAsAdmin, loginAsProvider,
loginAsCustomer) navigate then click immediately which can fail on slow CI;
before clicking await the page to be ready and the button to be
visible/interactive (e.g., wait for load state and/or wait for the role-based
locator to be visible/enabled) and then perform the click, keeping the existing
call to handleLoginRedirect; apply this same wait pattern to all three functions
so each waits for the target button (via page.getByRole(...)) to be ready before
clicking.
- Around line 43-46: The logout function should defensively ensure the "Sair"
button is visible before clicking and use explicit timeouts for waiting so tests
don't hang: update export async function logout(page: Page) to await a
visibility/waitForSelector or page.getByRole(...).waitFor({ state: 'visible',
timeout: <reasonable-ms> }) (or assert isVisible) before calling click, call
page.waitForURL(/\/(login|admin\/login|provider\/login)/, { timeout:
<reasonable-ms> }), and wrap the sequence in a try/catch to surface a clear
error message if visibility/click or the URL wait fails; reference the logout
function, Page, page.getByRole('button', { name: /sair/i }) and page.waitForURL
to locate where to apply these changes.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/admin-portal/overview.md`:
- Line 234: Substitua a frase mista em inglês/português "Os testes exercising
the OAuth flow via Keycloak (signIn(\"keycloak\")) em vez de formulários de
email/password" por uma versão totalmente em pt-BR, p.ex. "Os testes exercitam o
fluxo OAuth via Keycloak (signIn('keycloak')) em vez de formulários de
email/senha"; mantenha a referência ao método signIn("keycloak") intacta e
ajuste "email/password" para "email/senha" para consistência editorial.
- Around line 102-110: O documento contém caminhos E2E conflitantes:
`src/Web/MeAjudaAi.Web.Admin/e2e/` e `tests/MeAjudaAi.Web.Admin.Tests/e2e/`;
pick one canonical path and update all occurrences to match it (including the
listing at `src/Web/MeAjudaAi.Web.Admin/ └── e2e/` and the entries around lines
233–234 that reference `tests/MeAjudaAi.Web.Admin.Tests/e2e/`), ensuring
examples, tree structures and any prose consistently reference the chosen
directory (`src/Web/MeAjudaAi.Web.Admin/e2e/` or
`tests/MeAjudaAi.Web.Admin.Tests/e2e/`) so the document no longer contains
contradictory paths.

In `@docs/architecture.md`:
- Around line 3236-3250: The fenced code block that begins with "src/Web/" is
missing a language tag which triggers markdownlint MD040; update the opening
fence from ``` to ```text so the block is explicitly marked as text (modify the
code block starting with the "src/Web/" listing in the architecture.md content).
- Around line 3205-3250: The docs disagree on the canonical E2E test location
(architecture.md uses src/Web/MeAjudaAi.Web.Admin/e2e while other docs use
tests/MeAjudaAi.Web.*.Tests/e2e); pick the canonical path (e.g., standardize on
tests/MeAjudaAi.Web.*.Tests/e2e), update the entry in the React file tree and
the Playwright bullet in architecture.md to that path, and update any other docs
(e.g., docs/admin-portal/overview.md and docs/roadmap-current.md) so all
references match; also ensure the Playwright config note (testDir) aligns with
the chosen path so users get correct setup/exec instructions.

In `@docs/roadmap-current.md`:
- Around line 617-621: Unifique o significado da Sprint 8E em todo o documento:
escolha a definição correta (por exemplo "Sprint 8E - E2E Tests React Apps
(Playwright)" ou "Sprint 8E (Mobile)") e atualize todas as ocorrências para essa
mesma descrição; especificamente, alinhe o cabeçalho "### ⏳ Sprint 8E - E2E
Tests React Apps (Playwright) (23 Mar - 4 Abr 2026)" com outras menções como
"Sprint 8E (Mobile)" para evitar conflito de escopo e datas, garantindo que
títulos, subtítulos e quaisquer referências de escopo/dateline usem o mesmo
texto e contexto.
- Around line 35-40: O roadmap declara o "Admin Portal" como "React (migrado
Sprint 8D)" com a stack listada (React 19 + TypeScript 5.7+, Tailwind CSS v4,
Zustand, React Hook Form + Zod) mas há referências conflitantes a Blazor em
outras seções; abra o documento e unifique o estado atual removendo ou
atualizando qualquer ocorrência de "Admin" associada a Blazor e padronize a
entrada para "Admin Portal — React (migrado Sprint 8D)" com a stack completa
mencionada para garantir consistência em todo o arquivo.

In `@src/Web/libs/e2e-support/base.ts`:
- Around line 13-23: handleLoginRedirect currently swallows a TimeoutError from
page.waitForURL and treats it as success; change it so when a TimeoutError is
caught you validate a post-login state (for example check page.url() or
waitForSelector of a known logged-in element) and only return silently if that
validation confirms a logged-in/session state, otherwise rethrow or throw a
descriptive error; keep references to handleLoginRedirect, page.waitForURL and
the TimeoutError branch when implementing the additional check.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/configs.spec.ts`:
- Around line 9-11: O teste em configs.spec.ts usa data-testid="cities-list",
"city-row" e "city-form" que não existem na UI; abra o componente
allowed-cities/page.tsx e ou (a) adicione esses atributos aos elementos
correspondentes (lista de cidades, linha de cidade e formulário de cidade) ou
(b) atualize configs.spec.ts para selecionar elementos já presentes na DOM (por
exemplo classes ou IDs atuais), garantindo que os seletores em configs.spec.ts
correspondam exatamente aos nomes dos elementos em allowed-cities/page.tsx.
- Around line 74-77: The test is filling non-existent form fields; update the
selectors to match services/page.tsx by replacing 'input[name="serviceName"]'
with 'input[name="name"]', remove the 'input[name="basePrice"]' fill entirely,
and instead interact with the category field (e.g., use
'select[name="categoryId"]' or the appropriate category input) before clicking
the "Salvar" button so the test fills only the actual fields: name, description
and categoryId.
- Around line 17-19: O teste está usando nomes de campo incorretos; atualize as
chamadas em configs.spec.ts para preencher os nomes corretos conforme
allowed-cities/page.tsx: substituir page.fill('input[name="cityName"]', ...) por
page.fill('input[name="city"]', ...), e substituir
page.fill('input[name="maxProviders"]', ...) por
page.fill('input[name="serviceRadiusKm"]', ...); mantenha o preenchimento do
campo 'state' conforme está.
- Around line 137-146: Os testes "should display general settings" e "should
update platform settings" usam seletores inexistentes
(data-testid="general-settings" e input[name="platformFee"]); atualize-os para
usar os elementos reais da UI — por exemplo, para verificar a aba de perfil use
um locator que procura pelo texto/aba "Perfil" ou pelos campos existentes
input[name="adminName"] e input[name="adminEmail"], e na atualização de
configurações preencha esses campos em vez de platformFee e verifique a mensagem
de sucesso; ajuste os nomes dos testes/selets para refletir "profile settings"
quando alterar os comportamentos em test('should display general settings') e
test('should update platform settings') para localizar e interagir com
adminName/adminEmail ou as tabs reais.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Around line 79-80: O selector page.getByRole('alert') não funciona para toasts
do Sonner; substitua todas as ocorrências de page.getByRole('alert') (por
exemplo na asserção await
expect(page.getByRole('alert')).toContainText(/aprova/i) e na outra asserção de
rejeição) por page.getByRole('status') para corretamente localizar o container
do toast e validar o texto.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/onboarding.spec.ts`:
- Line 34: The selector used in the assertion is case-sensitive and may fail if
the UI capitalizes the message; update the locator used in the assertion (the
page.locator(...) passed into expect(...).toBeVisible()) to use a
case-insensitive text match (e.g., a regex text selector with the i flag) so
"email inválido" and "Email inválido" both match.
- Around line 82-88: O fluxo completo dentro do bloco que verifica
page.locator('input[name="cep"]').isVisible() omite o preenchimento dos campos
'city' e 'state' (preenchidos no teste isolado), o que pode causar falhas
intermitentes; ajuste o bloco que usa page.fill('input[name="cep"]', ...),
page.fill('input[name="street"]', ...), etc. para também preencher
page.fill('input[name="city"]', '<cidade>') e page.fill('input[name="state"]',
'<estado>') antes de clicar em page.click('button:has-text("Próximo")'),
mantendo os mesmos valores usados no teste isolado e respeitando a checagem de
visibilidade com page.locator.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 49-72: The two tests inside the test.describe('Provider Web App -
Mobile Responsiveness') block—specifically the tests named 'should render
correctly on mobile viewport' and 'should have touch-friendly elements on
mobile' that call page.goto('/provider/dashboard') (and similarly another test
visiting '/admin/dashboard') are in the Customer app e2e suite and will 404;
either move these test cases into the correct app suites
(MeAjudaAi.Web.Provider/e2e and MeAjudaAi.Web.Admin/e2e) or change their
navigation to absolute URLs that point to the Provider/Admin baseURLs, updating
the page.goto calls accordingly so they use the proper host/port for those apps
while keeping the rest of the test logic (viewport via mobileViewport, locator
checks, and button boundingBox assertions) intact.
- Around line 119-137: The test "should meet FID threshold" never generates a
first-input entry because it doesn't perform a user interaction; update the test
to register the PerformanceObserver (the code that creates new
PerformanceObserver and resolves metrics) before simulating a real user gesture,
then programmatically trigger a real user interaction (e.g., await
page.click('body') or a specific interactive element) so the PerformanceObserver
can capture a 'first-input' entry (fidEntry). Ensure you wait for the observer
to resolve (or extend the timeout) and then assert metrics.fid < 100 as before;
reference the test name, the PerformanceObserver/ fidEntry logic and the metrics
variable when making the change.
- Around line 102-116: The LCP measurement can race/leave the
PerformanceObserver attached; inside the page.evaluate Promise (where metrics is
produced) ensure you only resolve once and always clean up: create a boolean
flag (e.g., resolved) so both the PerformanceObserver callback and the
setTimeout check/set the flag before calling resolve, call observer.disconnect()
inside the observer callback after capturing the LCP, and clear the timeout
(clearTimeout) when resolving from the observer; also ensure the timeout path
disconnects the observer before resolving—apply these changes around the
PerformanceObserver, setTimeout and resolve logic so the observer is always
disconnected and the Promise resolves exactly once.

---

Duplicate comments:
In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Around line 9-11: The tests expect data-testid attributes that don't exist:
update the providers page component (providers/page.tsx) and the related
provider row/detail elements to include data-testid="providers-table",
data-testid="provider-row", data-testid="provider-status",
data-testid="documents-list", data-testid="provider-detail",
data-testid="approve-button" and data-testid="view-details" on the corresponding
<table>, row, status cell, documents list, detail panel and action buttons (or
if you prefer not to add attributes, change the tests to use existing selectors
such as table, tbody tr, aria-label values or role-based queries); ensure the
exact testid strings match those used in the spec so the locators in the test
(providers.spec.ts) can find the elements.

---

Nitpick comments:
In `@src/Web/libs/e2e-support/base.ts`:
- Around line 43-46: A função logout tenta clicar no botão "Sair" sem verificar
se ele existe, causando timeout se o usuário já estiver deslogado; modifique
logout (exported function logout(page: Page)) para primeiro localizar o botão
via page.locator or page.getByRole (name: /sair/i) e checar
presença/visibilidade (ex.: count()>0 ou isVisible()) antes de clicar, só
executar o click e o await page.waitForURL(...) quando o botão existir; se não
existir, retorne imediatamente para evitar falha do teste.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/providers.spec.ts`:
- Around line 30-31: The test uses a brittle fixed sleep via
page.waitForTimeout(500); replace this magic wait with an explicit wait that
reflects the real condition: e.g., wait for the filter result element or network
response instead. Locate the usage of page.waitForTimeout in providers.spec.ts
and change it to an appropriate explicit wait such as locator.waitFor({ state:
'visible' }) on the element that indicates the filter has applied (or
page.waitForResponse matching the filter request) so the test only proceeds once
the UI or network state is ready.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/onboarding.spec.ts`:
- Line 1: The import statement in onboarding.spec.ts includes unused symbols
loginAsCustomer and logout; remove these unused imports from the import
declaration so it only imports the actually used symbols (test, expect) to clean
up the file and avoid linter warnings.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 182-183: The current assertion uses lazyLoadedImages and will fail
if there are no lazy images above the fold; update the check to only assert lazy
loading for images below the fold by computing viewport height (e.g.,
window.innerHeight or document.documentElement.clientHeight), filter
imagesWithSrc by element.getBoundingClientRect().top > viewportHeight to get
imagesBelowFold, then either assert that every image in imagesBelowFold has
loading === 'lazy' or make the assertion conditional (only run expect when
imagesBelowFold.length > 0). Reference the existing variables lazyLoadedImages
and imagesWithSrc and replace the current expect line with the
conditional/below-the-fold-based assertion.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Web/MeAjudaAi.Web.Admin/e2e/performance.spec.ts`:
- Around line 17-23: The test "should collapse sidebar on mobile" fails because
the Sidebar component's <aside> element lacks the data-testid="sidebar"
attribute; update the Sidebar component (the <aside> element in the Sidebar
component) to include data-testid="sidebar" so the locator in the e2e test can
find it, then run the e2e test to confirm the locator
(page.locator('[data-testid="sidebar"]')) now succeeds.
- Around line 10-15: O componente de layout (sidebar.tsx) está sem os atributos
usados pelos testes; abra o componente Sidebar e adicione
data-testid="mobile-menu-toggle" no botão hamburger (o elemento de toggle do
menu), data-testid="sidebar" no elemento <aside> principal do sidebar e
data-testid="mobile-menu" no container do menu móvel (o elemento que aparece em
mobile); assim os seletores usados em performance.spec.ts poderão localizar
corretamente os elementos.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Line 37: O teste de performance usa await page.goto('/busca') mas o aplicativo
realmente navega para '/buscar' (ver componente Header em header.tsx); atualize
a chamada page.goto no arquivo performance.spec.ts para usar '/buscar' para
evitar 404 e garantir que asserções de layout mobile atinjam a rota correta.

---

Duplicate comments:
In `@docs/admin-portal/overview.md`:
- Around line 102-113: Atualize a seção E2E para refletir a nova estrutura de
testes: substitua referências a src/Web/MeAjudaAi.Web.Admin/e2e/ e
src/Web/libs/e2e-support/base.ts pela pasta de testes atual
tests/MeAjudaAi.Web.*.Tests/ e pelo local dos fixtures compartilhados (onde o
shared fixture loginAsAdmin agora vive), atualizando a árvore de exemplo, os
caminhos nos trechos de documentação e o nome/posição do fixture `loginAsAdmin`
para apontar para a nova pasta de shared fixtures usada pelo PR.

In `@docs/architecture.md`:
- Around line 3113-3169: Update the E2E section in docs/architecture.md to match
the new PR layout: replace all references to co-located e2e folders (e.g.,
src/Web/MeAjudaAi.Web.Admin/e2e, src/Web/MeAjudaAi.Web.Customer/e2e,
src/Web/MeAjudaAi.Web.Provider/e2e) with the new test project paths
(tests/MeAjudaAi.Web.Admin.Tests, tests/MeAjudaAi.Web.Customer.Tests,
tests/MeAjudaAi.Web.Provider.Tests) and document the shared tests/libs location
(e.g., tests/shared or libs/e2e-support) plus update the Playwright config
description to reflect the single test repo layout and any changed
testDir/baseURL/grep expectations so examples and onboarding match the PR.
- Around line 2781-2827: Split the chapter into explicit "Current architecture
(React + Next.js + Tailwind CSS)" and "Legacy (Blazor)" subsections: keep the
existing React content (the "React + Next.js + Tailwind CSS" heading, mermaid
diagram, and the Stack Tecnológica table) under the Current architecture
subsection, and move any Blazor-specific examples (references to Program.cs OIDC
and .razor files) into a separate "Legacy (Blazor)" subsection with a short note
that these are historical/legacy examples; update headings and add a one-line
disclaimer in each subsection clarifying which examples are active vs. legacy so
readers cannot confuse Program.cs/.razor Blazor code with the current React
implementation.

In `@docs/roadmap-current.md`:
- Around line 617-621: O documento usa “Sprint 8E” com significados divergentes;
unifique o nome em todo o roadmap para evitar ambiguidade: escolha entre “Sprint
8E - E2E React Apps (Playwright)” (como no cabeçalho e branch
`feature/sprint-8e-e2e-react-apps`) ou “Sprint 8E (Mobile)”, e atualize todas as
ocorrências do outro termo para o escolhido; verifique e altere títulos,
subtítulos e descrições que mencionem “Sprint 8E (Mobile)” para corresponder ao
termo único, mantendo o período (23 Mar - 4 Abr 2026) e a branch referenciada
consistentes.
- Around line 35-39: O bloco "Admin Portal (React - migrado Sprint 8D)" está
inconsistente porque mistura indicação de migração para React com descrições de
Blazor/dual stack; atualize o parágrafo inteiro para uma única narrativa
afirmando que o Admin já foi migrado para React (ou, se ainda não foi, marque
claramente como "em migração") e remova qualquer menção a Blazor/dual stack;
garanta que as tecnologias listadas (React 19, TypeScript 5.7+, Tailwind CSS v4,
Zustand, React Hook Form + Zod) correspondam ao estado escolhido e ajuste a
frase de cabeçalho "Admin Portal (React - migrado Sprint 8D)" para refletir o
estado final de forma inequívoca.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 83-116: The test can falsely pass because document.body.click()
inside page.evaluate may not produce a trusted first-input entry and the
assertion skips when metrics.fid is null; move the user interaction out of the
page.evaluate and perform a real user gesture with Playwright (e.g., use
page.mouse.click(x,y) or await page.click('body') before collecting metrics) so
the PerformanceObserver in the evaluate callback can capture a genuine
first-input entry, and change the assertion to explicitly require a non-null FID
(e.g., expect(metrics.fid).not.toBeNull()) before asserting
expect(metrics.fid).toBeLessThan(100); update references to the test name, the
metrics variable, and the PerformanceObserver logic accordingly.

---

Nitpick comments:
In `@docs/admin-portal/overview.md`:
- Around line 159-167: O componente AdminProtected está chamando
router.push('/login') durante a render (inside AdminProtected after useSession),
o que pode causar re-renders indesejados; move the redirect into a useEffect
that watches status and session: keep the existing loading branch returning
<Spinner />, and instead of calling router.push during render, add a useEffect
that runs when status or session change and calls router.push('/login') if
status !== 'loading' and !session; ensure the render returns null (or a
fallback) while redirecting to avoid side effects during render.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/performance.spec.ts`:
- Around line 5-8: The test file name (performance.spec.ts) doesn't match the
test suite title ("Admin Portal - Mobile Responsiveness"); either rename the
file to something like mobile-responsiveness.spec.ts or responsive.spec.ts, or
change the test.describe title to reflect performance tests (e.g., "Admin Portal
- Performance"); update any test runner configs or imports that reference the
file name if you rename it, and keep the test.describe string and filename
consistent (reference: the test.describe block and the file name
performance.spec.ts).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/admin-portal/overview.md`:
- Around line 102-119: Update the documentation to reflect the actual locations:
change the E2E tests path from tests/MeAjudaAi.Web.Admin.Tests/e2e/ to
src/Web/MeAjudaAi.Web.Admin/e2e/ (the actual test files include
providers.spec.ts, auth.spec.ts, configs.spec.ts, dashboard.spec.ts,
mobile-responsiveness.spec.ts) and update the shared fixtures path from
tests/MeAjudaAi.Web.Shared.Tests/base.ts to src/Web/libs/e2e-support/base.ts
(which exports loginAsAdmin, loginAsProvider, loginAsCustomer and logout);
ensure the overview.md examples and the listed fixture exports reference these
real file paths and the existing exported helper names.

In `@docs/architecture.md`:
- Around line 3177-3207: The docs entry incorrectly points to the old
shared-fixtures location; update the architecture documentation to reference the
actual shared E2E support module that exports the helpers loginAsAdmin,
loginAsProvider, loginAsCustomer and logout and remove the obsolete
tests/MeAjudaAi.Web.Shared.Tests/base.ts reference so consumers know to import
those helpers from the real shared support module; ensure the tests listing
reflects the new shared-support placement and the example import paths in the
docs use the module that contains those exported functions.

In `@docs/roadmap-current.md`:
- Line 630: Atualize a referência aos fixtures E2E na documentação corrigindo o
caminho mencionado; substitua a entrada que aponta para
tests/MeAjudaAi.Web.Shared.Tests/base.ts pela localização real onde estão
exportados loginAsAdmin, loginAsProvider, loginAsCustomer e logout
(src/Web/libs/e2e-support/base.ts) para que o documento aponte para o arquivo
correto e reflita os símbolos exportados.

In `@src/Web/MeAjudaAi.Web.Admin/components/layout/sidebar.tsx`:
- Around line 47-58: No JSX attributes should use `class`; change the invalid
`class` props to `className` on the mobile toggle button and the backdrop div in
the sidebar component (the elements using onClick={() => setIsOpen(true)} /
data-testid="mobile-menu-toggle" and the conditional backdrop rendered when
isOpen is true). Ensure both occurrences are updated (the button with <Menu />
and the div with fixed inset-0 bg-black/50) and scan the rest of sidebar.tsx for
any other `class` → `className` fixes so TypeScript/React typings build
correctly.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/dashboard.spec.ts`:
- Around line 165-170: O teste "should display loading state while fetching
data" está sujeito a race condition porque verifica o spinner logo após
page.goto() sem interceptar a chamada de dados; use page.route(...) para mockar
a API (ou adicionar um delay) ou aguarde explicitamente a requisição com
page.waitForResponse(...) antes de executar expect(on) no locator
'[data-testid="dashboard-loading"]' para garantir que o estado de loading seja
visível durante a asserção.
- Around line 145-156: The test 'should refresh data on button click' is flaky
because it uses a fixed wait (waitForTimeout(1000)) and only asserts that
kpiValueAfter is defined; replace the fixed sleep with a reactive wait that
waits for the KPI value to change and assert the values differ. Specifically, in
the test body locate the refresh button (refreshButton) and capture
kpiValueBefore, click refreshButton, then use a wait-for condition (e.g.,
waitFor or locator.waitFor with a predicate) to wait until the locator for
'[data-testid="kpi-total-providers"] [data-testid="kpi-value"]' textContent
changes from kpiValueBefore, then read kpiValueAfter and assert kpiValueAfter
!== kpiValueBefore to confirm the refresh actually updated data.
- Around line 172-181: O teste "should handle API error gracefully" atualmente
só lê o DOM e pode passar sem erro real; altere-o para injetar uma falha via
page.route() antes de navegar (ou antes da ação que chama a API) para forçar a
resposta de erro HTTP, então remova a condição if(hasError) e sempre assert que
errorMessage (locator '[data-testid="dashboard-error"]') contém o texto esperado
e que retryButton (locator '[data-testid="retry-button"]') está visível;
mantenha os nomes das variáveis errorMessage e retryButton e garanta que a rota
mock retorne um status de erro e corpo apropriado para disparar o tratamento de
erro da UI.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/mobile-responsiveness.spec.ts`:
- Around line 10-15: The test "should render correctly on mobile viewport" fails
because the sidebar in sidebar.tsx is hidden by default (aside starts with
translate-x-full when isOpen=false); update the test to emulate user interaction
by clicking the mobile hamburger/toggle before asserting the menu is visible:
after setting mobileViewport and navigating to '/admin/dashboard' add a click on
the hamburger toggle (the button that toggles isOpen — e.g., the mobile
hamburger data-testid used in the UI) and then assert that
'[data-testid="mobile-menu"]' is visible.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 171-182: O teste "should not have excessive requests" atualmente
só conta requests com 'localhost'/'127.0.0.1' dentro do handler
page.on('request'), o que ignora tráfego de terceiros; corrija isto alterando o
filtro no handler para contabilizar todos os requests relevantes (remova a
checagem de origem ou adicione uma whitelist/blacklist explícita) e ajustar a
expectativa expect(requests.length).toBeLessThan(50) de acordo, ou
alternativamente renomeie o caso de teste para algo como "should not have
excessive same-origin requests" para deixar claro que só mede same-origin,
mantendo a lógica atual em page.on('request') e a asserção.
- Around line 78-80: The current LCP check can pass when metrics.lcp is null
because the threshold assertion is skipped; update the test around metrics.lcp
to first assert it is defined/non-null (e.g., expect(metrics.lcp).toBeDefined()
or toBeGreaterThan(0)) and then assert the numeric threshold
(expect(metrics.lcp).toBeLessThan(2500)), ensuring both checks run so a missing
metric fails the test; look for the metrics.lcp check in the performance.spec.ts
test and add the presence assertion before the toBeLessThan assertion.
- Around line 123-131: The CLS calculation currently sums all layout-shift
entries (within page.evaluate using performance.getEntriesByType('layout-shift')
and entries.forEach) which is the old approach; change it to the official
"session windows" algorithm: filter out entries with entry.hadRecentInput, then
iterate the remaining entries in time order grouping them into windows where
consecutive shifts are < 1s apart and each window duration ≤ 5s, compute the sum
of entry.value per window, and return the maximum window sum (e.g., replace the
single accumulator cls with a maxCls computed from per-window sums and return {
cls: maxCls }). Ensure this logic lives inside the same page.evaluate block so
metrics captures the session-windowed CLS.
- Around line 137-143: O tempo atual mede na verdade até o evento load porque
page.goto() aguarda load por padrão; para medir apenas domcontentloaded atualize
o teste dentro do bloco "should load page within acceptable time" para iniciar
startTime antes da navegação e chamar page.goto('/', { waitUntil:
'domcontentloaded' }) (removendo o page.waitForLoadState('domcontentloaded')
redundante), então calcular loadTime = Date.now() - startTime e manter a
asserção expect(loadTime).toBeLessThan(3000); referencie as variáveis startTime,
loadTime e os métodos page.goto / page.waitForLoadState ao aplicar a mudança.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/profile.spec.ts`:
- Around line 235-240: The test risks an out-of-bounds access by calling
ratingStars.nth(4) without ensuring there are at least five stars; update the
check around the ratingStars locator (variables ratingStars and starsCount) to
assert starsCount >= 5 before clicking the fifth star, or compute the target
index safely (e.g., use Math.min(4, starsCount - 1) or click the last star) and
apply the same guard/fix to the other occurrence at lines 262-265; ensure the
expectation and subsequent click use the safe index instead of unguarded nth(4).
- Around line 49-59: The test "should show login prompt for guest users" uses a
conditional that masks failures; remove the if-check and assert
deterministically that the login prompt exists and is visible by replacing the
conditional branch with explicit expectations on the locator returned by
page.locator('[data-testid="login-prompt"]') (e.g., assert count is > 0 or use
toBeVisible()/toHaveCount) so the test fails when the element is absent; apply
the same change pattern to the other tests noted (the ones using the same
count-if pattern).
- Line 276: Remove the silent catch so test failures propagate: in
profile.spec.ts, locate the assertion awaiting page.locator('text=Obrigado pela
avaliação') and delete the trailing .catch(() => {}); keep the await
expect(...).toBeVisible({ timeout: 5000 }) as-is (or replace with a deliberate
try/catch that rethrows or logs then throws) so a missing confirmation fails the
test instead of being suppressed.
- Line 3: The test suite's describe title "Customer Web App - Provider Profile
View" (test.describe in profile.spec.ts) lacks the required e2e marker so it may
be filtered out by the global grep (/e2e/) in playwright.config.ts; update the
test.describe titles used across e2e specs—starting with test.describe in
src/Web/MeAjudaAi.Web.Customer/e2e/profile.spec.ts—to include the prefix "@e2e"
(e.g., "@e2e Customer Web App - Provider Profile View") so the CI collects these
suites; ensure all other describe blocks in the e2e folder follow the same
naming convention.

---

Nitpick comments:
In `@docs/architecture.md`:
- Line 3236: The fenced code block that shows the file structure is missing a
language specifier and triggers MD040; update the code block surrounding the
file tree (the triple-backtick block in the architecture document) to include a
language specifier such as "text" (i.e., change ``` to ```text) so the linter
recognizes it; ensure you do this for the specific code block that starts with
"src/Web/" so the warning is resolved.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 83-116: The test currently measures FID (test "should meet FID
threshold") which is deprecated; update it to measure INP instead by renaming
the test (e.g., "should meet INP threshold") and replacing the
PerformanceObserver logic inside the page.evaluate: observe type 'event' with
buffered: true, filter entries where entry.entryType === 'event', compute INP as
the maximum candidate across those entries using the web.dev formula (for each
entry use processingStart + duration - startTime when processingStart exists,
otherwise use duration), resolve with { inp: calculatedValue } (and timeout to
return inp: null), then assert metrics.inp is not null and meets the INP
threshold (adjust expectation from metrics.fid to metrics.inp and update the
numeric threshold accordingly).

In `@src/Web/MeAjudaAi.Web.Customer/e2e/profile.spec.ts`:
- Line 65: There are multiple uses of fixed sleeps (page.waitForTimeout) in
profile.spec.ts which make tests flaky and slow; replace each await
page.waitForTimeout(...) with deterministic waits tied to the expected state:
after navigations use page.waitForLoadState('networkidle') or
expect(page).toHaveURL(expectedPath), and for DOM changes wait on specific
locators via await page.locator('<selector>').waitFor({state: 'visible' |
'attached'}) or await expect(page.locator('<selector>')).toBeVisible(); update
all occurrences (the calls to page.waitForTimeout in this spec) to use the
appropriate page.waitForLoadState/expect(...).toHaveURL or
locator.waitFor/expect(locator).toBeVisible with the correct selectors for the
element each test is relying on.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/Web/MeAjudaAi.Web.Admin/auth.ts`:
- Around line 28-35: The current env-check allows placeholders in production
(only console.warn) — change the production branch so missing keycloakClientId,
keycloakClientSecret, or keycloakIssuer throws an error (e.g., throw new
Error("Missing Keycloak environment variables")) to fail fast; update the
conditional in the block that references
keycloakClientId/keycloakClientSecret/keycloakIssuer accordingly. Also
consolidate usage of the existing requireEnv helper: call requireEnv for those
three vars (or remove requireEnv if you prefer direct checks) so the helper is
not unused and environment validation is centralized.

---

Nitpick comments:
In `@src/Web/MeAjudaAi.Web.Admin/auth.ts`:
- Around line 13-22: The requireEnv function is unused and duplicates
environment-reading policy; delete the requireEnv definition and any references,
and centralize environment validation/reading into the existing configuration
loader (instead of duplicating logic here). Specifically, remove the requireEnv
function from auth.ts, move its intended behavior (required vs optional envs,
validation, and logging policy) into your single config module (or a new
getRequiredEnv/getConfig function), update code that previously/read envs to
consume that centralized config API, and ensure the same production-only warning
behavior is preserved there.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docs/architecture.md`:
- Around line 2781-2829: The document currently presents React/Next.js +
NextAuth.js as the active stack while still showing legacy Blazor OIDC
components (AddOidcAuthentication, RemoteAuthenticatorView, App.razor) as if
they are current; update the auth section to reconcile this by explicitly
marking AddOidcAuthentication, RemoteAuthenticatorView and App.razor as
legacy/deprecated and clarifying that the current authentication flow uses
NextAuth.js with Keycloak OIDC for React/Next.js, or alternatively remove the
legacy Blazor snippets entirely and add a short migration note linking the
legacy components to their replacement in the NextAuth.js flow so there is a
single clearly identified "current" architecture.

In `@docs/roadmap-current.md`:
- Line 655: The roadmap notes that "**Mobile Apps**: De-scoped from MVP to Phase
2" but the Risks section still reserves Sprint 9 buffer for "MAUI Hybrid
Platform-Specific Issues"; update the Risks section to reflect the mobile
de-scope by removing or reprioritizing the "MAUI Hybrid Platform-Specific
Issues" risk in Sprint 9 and any other risk entries that assume mobile remains
in MVP, and adjust Sprint 9 buffer and risk priorities accordingly so the Mobile
Apps de-scope and Sprint 9 plan are consistent.

In `@prompts/plano-implementacao-testes-react.md`:
- Around line 252-298: Tests import renderHook from `@test-support` but the file
only wraps and exports render (not renderHook), so hooks that need
QueryClientProvider fail; add and export a wrapped renderHook that uses the same
AllTheProviders wrapper (or a wrapper factory that accepts a custom client from
createTestQueryClient) so hook tests run with React Query context. Specifically,
add a customRenderHook function that imports renderHook (and
RenderHookOptions/RenderHookResult types if needed) from the testing library,
calls renderHook(ui, { wrapper: AllTheProviders, ...options }), and export it
(e.g., export { customRenderHook as renderHook }) alongside the existing
exports; keep AllTheProviders and createTestQueryClient unchanged and reuse them
so both render and renderHook provide the QueryClientProvider.
- Around line 707-723: The CI test script "test:ci" currently runs vitest
without per-app configs; update the "test:ci" script in package.json to follow
the same per-project config pattern used by the other scripts (i.e., include
--config MeAjudaAi.Web.Customer/vitest.config.ts, --config
MeAjudaAi.Web.Admin/vitest.config.ts and --config
MeAjudaAi.Web.Provider/vitest.config.ts) and keep the desired reporters/coverage
flags (--coverage --reporter=junit --reporter=json-summary) so each app's
setupFiles, include patterns and coverage settings are loaded; modify the
"test:ci" entry accordingly (or run vitest sequentially for each config like the
"test" script but with the CI reporters).

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 56-64: The PerformanceObserver callback currently picks the first
LCP candidate via entries.find(...), which underestimates LCP; change the logic
in the PerformanceObserver callback (the observer handling in the
e2e/performance.spec.ts where variables resolved, entries, lcpEntry and
resolve({ lcp: ... }) are used) to select the last entry from list.getEntries()
(e.g., entries[entries.length - 1] or equivalent) as the lcpEntry before setting
resolved, disconnecting the observer, and calling resolve so the true, final LCP
value is recorded.

---

Duplicate comments:
In `@docs/architecture.md`:
- Around line 3176-3204: The documented E2E tree and Playwright config are
pointing to nonexistent locations (e.g., "src/MeAjudaAi.Web.Admin/e2e" and
testDir: './src') whereas the repo uses "src/Web/MeAjudaAi.Web.Admin/e2e",
"src/Web/MeAjudaAi.Web.Customer/e2e", "src/Web/MeAjudaAi.Web.Provider/e2e" and
"src/Web/libs/e2e-support/base.ts"; update the architecture.md snippet to show
the actual directories (replace top-level "src/" with "src/Web/") and adjust the
Playwright config example (change testDir from './src' to './src/Web' and update
any baseDir/baseURL notes referencing the old paths) so the documentation
matches the real repo layout and the exported helper reference (base.ts) points
to src/Web/libs/e2e-support/base.ts.

In `@docs/roadmap-current.md`:
- Around line 35-40: O bloco "Admin Portal (React - migrado na Sprint 8D)"
indica migração completa, mas o restante do documento ainda contém
narrativas/tabelas referindo-se a Blazor; corrija a inconsistência atualizando o
texto em docs/roadmap-current.md para refletir o estado real: ou marcar a
migração como "parcial" e documentar os componentes ainda em Blazor, ou remover
todas as referências a Blazor e ajustar as tabelas/narrativas subsequentes para
React/TypeScript; busque e atualize as seções que mencionam "Blazor", "Admin
Portal" e qualquer tabela de status para que todas usem o mesmo estado
(migrado/parcial) e linguagem consistente.
- Around line 624-631: The roadmap text references nonexistent test project
paths ("tests/MeAjudaAi.Web.*.Tests/e2e/") while the PR added E2E suites under
the actual projects (e.g., "src/Web/MeAjudaAi.Web.Customer/e2e",
"src/Web/MeAjudaAi.Web.Provider/e2e", "src/Web/MeAjudaAi.Web.Admin/e2e"); update
the Scope bullets (Playwright/Implement Test Specs/Customer/Provider/Admin
entries and Shared Fixtures/CI Integration notes) to use the real project
identifiers and correct e2e directories so the roadmap matches the implemented
locations.

In `@src/Web/MeAjudaAi.Web.Admin/auth.ts`:
- Around line 13-19: The current auth bootstrap silently falls back to
placeholder/localhost Keycloak values outside CI and never uses getRequiredEnv;
change it to fail fast by using getRequiredEnv to read required Keycloak
variables (e.g., KEYCLOAK_BASE_URL, KEYCLOAK_REALM, KEYCLOAK_CLIENT_ID) instead
of injecting defaults, and only allow dummy fallbacks when process.env.CI is
explicitly truthy; update the Keycloak init code paths that currently set
placeholder values to call getRequiredEnv (or conditionally allow dummy values
when CI) so missing secrets throw an error at startup outside CI.

In `@src/Web/MeAjudaAi.Web.Admin/e2e/dashboard.spec.ts`:
- Around line 166-170: The test "should display loading state while fetching
data" swallows assertion failures by using .catch(() => {}); remove the .catch
and instead simulate a delayed API response (use page.route or network mocking
for the dashboard data) so the loading spinner at locator
'[data-testid="dashboard-loading"]' is actually shown, then assert with await
expect(loadingSpinner).toBeVisible({ timeout: 10000 }) (no .catch) so the test
fails correctly if the spinner never appears.
- Around line 145-157: The test "should refresh data on button click" currently
asserts that kpiValueLocator (data-testid="kpi-total-providers") changes, which
can be flaky; update the test to verify a reliable indicator instead: use the
refreshButton locator (data-testid="refresh-dashboard") to trigger the action
and then assert either that the last-updated element (e.g.
[data-testid="last-updated"]) textContent changed or that the network refresh
request completed by intercepting the refresh API call; modify the test to
capture the pre-refresh last-updated value (or wait for the mocked network
route) and then after refresh click wait for the updated last-updated value (or
for the routed response) and assert it changed or that the route was called,
replacing the unreliable kpiValueLocator assertion.

In `@src/Web/MeAjudaAi.Web.Customer/e2e/performance.spec.ts`:
- Around line 135-166: The CLS windowing logic under validEntries (variables
maxCls, currentWindowSum, windowStartTime) is incorrect because it resets based
on windowStartTime only; update it to follow the official CLS session rules:
iterate sorted validEntries and start a new session when the gap between the
current entry and the previous entry is >= 1000ms OR the current entry's
startTime minus the session's windowStartTime is >= 5000ms; track lastEntryTime
(previousStart) to check the 1s gap, update windowStartTime only when starting a
new session, accumulate currentWindowSum otherwise, and update maxCls whenever
you start a new session or at the end. Use the existing validEntries, maxCls,
currentWindowSum, windowStartTime names to locate and replace the windowing
logic.
- Around line 83-125: The PerformanceObserver is registered too late because the
test triggers page.click before the observer can capture the interaction; modify
the test "should meet INP threshold" so the observer is created and
observer.observe(...) is called before the user interaction, then trigger the
click from within the page.evaluate block (or otherwise ensure page.click runs
only after the observer resolves registration), set observer.observe to include
durationThreshold: 0 and buffered: true (e.g. observer.observe({ type: 'event',
buffered: true, durationThreshold: 0 })), and keep the fallback setTimeout
logic; update references to the observer, metrics, and the setTimeout timeout if
needed to ensure short interactions are captured and the promise resolves
correctly.

---

Nitpick comments:
In `@prompts/plano-implementacao-testes-react.md`:
- Around line 120-126: Remova a recomendação de instalar o pacote deprecated
`@testing-library/react-hooks` do plano; mantenha apenas a instrução de instalar
jest-axe. Concretamente, elimine a linha que sugere "npm install --save-dev
`@testing-library/react-hooks`" e deixe a recomendação para usar o renderHook
re-exportado por test-utils.tsx (o plano já usa renderHook via test-utils.tsx),
para evitar dependências redundantes e caminhos duplicados para a mesma API.